import ToeUpload from '@/components/UploadDialog/index';
import {
  getDriveParaCalByPage,
  addDriveParaCal,
  delDriveParaCal,
  delDriveParasCal,
  updateDriveParaCal,
  uploadDriveParaCalExcel,
  driveParaCalExcelExport,
} from '@/services/drivepara/driveparacal';
import { uploadLicenseExcel } from '@/services/sales/license';
import { getS210motorList, getV90motorList } from '@/services/sales/salesNeedInfo';
import type { EditableFormInstance } from '@ant-design/pro-components';
import { PageHeaderWrapper } from '@ant-design/pro-layout';
import type { ActionType, ProColumns } from '@ant-design/pro-table';
import { Form, Input, message, Modal, Card } from 'antd';
import React, { useRef, useState } from 'react';
import { PlusOutlined } from '@ant-design/icons';
import ProTable from '@ant-design/pro-table';
import Button from 'antd/es/button';
import styles from '@/pages/sales/style.less';

import DebounceSelect from '@/components/DebounceSelect';
import { EditableProTable } from '@ant-design/pro-table';

interface TableFormDateType {
  id: string;
  workId?: string;
  name?: string;
  department?: string;
  isNew?: boolean;
  editable?: boolean;
}

interface UserValue {
  label: string;
  value: string;
}

async function fetchV90motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getV90motorList({ blurry: username }).then((res) => {
    return res.data.map((item) => {
      return {
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

async function fetchS210motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getS210motorList({ blurry: username }).then((res) => {
    return res.data.map((item) => {
      return {
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

const DriveParaLib: React.FC<{}> = () => {
  const [modalVisit, setModalVisit] = useState(false); // 新建和编辑提示框
  const [deleteVisit, setDeleteVisit] = useState(false); // 删除提示框

  const [formTitle, setFormTitle] = useState('导入/导出'); //
  const [rowData, setRowData] = useState({ id: '' }); // 保存行值
  const actionRef = useRef<ActionType>();
  const editorFormRef = useRef<EditableFormInstance<DataSourceType>>();
  const [isCreate, setIsCreate] = useState(false);
  const [form] = Form.useForm();
  // 表格数据
  const [dataSource, setDataSource] = useState<DataSourceType[]>([]);
  const [uploadVisit, setUploadVisit] = useState(false); //上传按钮显示
  const uploadRef = useRef(null);
  const [confirmLoading, setConfirmLoading] = useState(false); //编辑框的disable
  const [modalContent, setModalContent] = useState('是否导入/导出？');

  /**
   * 穿梭框的数据设置
   */
  const columns: ProColumns[] = [
    {
      title: '序号',
      dataIndex: 'index',
      valueType: 'index',
      width: 80,
    },
    {
      title: '唯一标识', //表头显示的名称
      search: false,
      hideInTable: true,
      dataIndex: 'identification', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '行业', //表头显示的名称

      dataIndex: 'vm', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路

      valueType: 'select',
      valueEnum: {
        1: { text: '电子' },
        2: { text: '电池' },
        3: { text: '物流' },
        4: { text: '汽车' },
        5: { text: '太阳能' },
        6: { text: '增材制造' },
        7: { text: '包装' },
        8: { text: '食品饮料' },
        9: { text: '金属加工' },
        10: { text: '其他' },
      },
      width: 100,
    },

    {
      title: '设备名称', //表头显示的名称

      dataIndex: 'deviceName', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },

    {
      title: '轴名称', //表头显示的名称
      search: false,
      dataIndex: 'shaftName', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },

    {
      title: '硬件标识符', //表头显示的名称
      search: false,
      dataIndex: 'hardwareidentifier', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },

    // {
    //   title: '驱动类型', //表头显示的名称
    //   dataIndex: 'driveType', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    //   valueType: 'select',
    //   valueEnum: {
    //     1: { text: 'v90' },
    //     2: { text: 's210' },
    //   },
    // },
    {
      title: '驱动类型', //
      search: false,
      key: 'driveType',
      dataIndex: 'driveType',
      valueType: 'select',
      valueEnum: {
        1: { text: 'V90', status: 'Default' },
        2: {
          text: 'S210',
          status: 'success',
        },
        // 0: {
        //   text: '第三方',
        //   status: 'warning',
        // },
      },
      formItemProps: {
        rules: [
          {
            required: true,
            message: '此项是必填项',
          },
        ],
      },
      width: 100,
    },
    {
      title: '电机订货号', //
      search: false,
      dataIndex: 'motorOrderNum',
      width: 200,
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        console.log(config, '--');
        // 这个是v90
        if (config.record.driveType === '1') {
          return (
            <DebounceSelect
              // value={value}
              placeholder="v90"
              fetchOptions={fetchV90motorList}
              onChange={(newValue, rowDate) => {
                console.log(rowDate.rowData, '-----newValue---');
                const rows = editorFormRef.current?.setRowData?.(config?.recordKey, {
                  ...rowDate.rowData,
                });
                console.log(rows, '---rows---');
              }}
              style={{ width: '100%' }}
            />
          );
        } else if (config.record.driveType === '2') {
          return (
            //这个是v210
            <DebounceSelect
              // value={value}
              placeholder="s210"
              fetchOptions={fetchS210motorList}
              onChange={(newValue, rowDate) => {
                console.log(rowDate, '-----newValue---');
                const rows = editorFormRef.current?.setRowData?.(config?.recordKey, {
                  ...rowDate.rowData,
                });
                console.log(rows, '---rows---');
              }}
              style={{ width: '100%' }}
            />
          );
        } else {
          return <Input />;
        }
      },
    },
    {
      title: '电机ID', //表头显示的名称
      search: false,
      dataIndex: 'motorId', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'digit',
      width: 100,
    },
    {
      title: '额定电流', //表头显示的名称
      search: false,
      dataIndex: 'ratedCurrent',
      valueType: 'digit',
      width: 100,
    },
    {
      title: '额定电流', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedCurrent',
      hideInTable: true,
    },
    {
      title: '额定扭矩', //表头显示的名称
      search: false,
      dataIndex: 'ratedTorque', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'digit',
      width: 100,
    },
    {
      title: '额定扭矩', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedTorque', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      hideInTable: true,
    },
    {
      title: '额定功率', //表头显示的名称
      search: false,
      dataIndex: 'ratedPower',
      valueType: 'digit',
      width: 100,
    },
    {
      title: '额定功率', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedPower',
      hideInTable: true,
    },
    {
      title: '编码器', //表头显示的名称
      search: false,
      dataIndex: 'ecoderType', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: '单圈绝对值编码器' },
        1: { text: '多圈绝对值编码器' },
        2: { text: '增量编码器' },
      },
      width: 100,
    },
    {
      title: '抱闸', //表头显示的名称
      search: false,
      dataIndex: 'brake',
      valueType: 'select',
      valueEnum: {
        0: { text: '不带抱闸' },
        1: { text: '带抱闸' },
      },
      width: 100,
    },
    {
      title: '额定速度', //表头显示的名称
      search: false,
      dataIndex: 'ratedSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '额定电压', //表头显示的名称
      search: false,
      dataIndex: 'ratedVoltage',
      width: 100,
    },
    {
      title: '电机惯量', //表头显示的名称
      search: false,
      dataIndex: 'motorInertia', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '电机惯量', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'motorInertia', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      hideInTable: true,
    },
    {
      title: '负载类型', //表头显示的名称

      dataIndex: 'loadType',
      valueType: 'select',
      valueEnum: {
        1: { text: '水平' },
        2: { text: '旋转' },
        3: { text: '垂直' },
        4: { text: '斜坡' },
        5: { text: '其它' },
      },
      width: 100,
    },
    {
      title: '机械结构', //表头显示的名称

      dataIndex: 'mechanicalStructure',
      valueType: 'select',
      valueEnum: {
        1: { text: '丝杠' },
        2: { text: '齿轮齿条' },
        3: { text: '皮带轮' },
        4: { text: '圆盘' },
        5: { text: '辊式带' },
        6: { text: '链条' },
      },
      width: 100,
    },
    {
      title: '控制模式', //表头显示的名称

      dataIndex: 'controlMode', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'TO' },
        2: { text: 'Epos' },
        3: { text: 'Speed' },
      },
      width: 100,
    },

    {
      title: '通讯报文', //表头显示的名称

      dataIndex: 'commTelegram',
      valueType: 'select',
      valueEnum: {
        1: { text: '105' },
        2: { text: '111' },
        3: { text: '102' },
        4: { text: '3' },
        5: { text: '1' },
      },
      width: 100,
    },

    {
      title: '附加报文', //表头显示的名称
      search: false,
      dataIndex: 'additionalTelegram', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'None' },
        2: { text: '750' },
      },
      width: 100,
    },
    {
      title: '电机方向', //表头显示的名称
      search: false,
      dataIndex: 'motorRotation',
      valueType: 'select',
      valueEnum: {
        0: { text: '正向' },
        1: { text: '反向' },
      },
      width: 100,
    },
    {
      title: '齿轮比负载(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'gearRationLoad', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '齿轮比电机(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'gearRationMotor',
      width: 100,
    },

    {
      title: '定位精度(V90 EPOS)', //表头显示的名称

      dataIndex: 'positionAccuracy', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '0.1mm' },
        2: { text: '0.01mm' },
        3: { text: '0.001mm' },
        4: { text: '0.1°' },
        5: { text: '0.01°' },
        6: { text: '0.001°' },
      },
      width: 100,
    },
    {
      title: '负载一圈的距离(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'loadOneTurnDistance',
      width: 120,
    },
    {
      title: '软限位激活(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitActive', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
      width: 100,
    },
    {
      title: '软限位(正)(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitPositive',
      width: 100,
    },

    {
      title: '软限位(负)(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitNegative', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '0-Vmax时间(V90 EPOS)', //表头显示的名称

      dataIndex: 'increaseTimeEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 100,
    },
    {
      title: 'Vmax-0时间(V90 EPOS)', //表头显示的名称

      dataIndex: 'decreaseTimeEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 100,
    },
    {
      title: '模态轴是否激活(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'modualActiveEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
      width: 120,
    },

    {
      title: '模态长度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'modualLengthEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: 'DI1(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di1Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      width: 120,
    },
    {
      title: 'DI2(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di2Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      width: 120,
    },
    {
      title: 'DI3(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di3Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      width: 120,
    },

    {
      title: 'DO1(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'do1Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      width: 120,
    },
    {
      title: '0-Vmax时间(V90TO/S210)', //表头显示的名称

      dataIndex: 'increaseTimeTO',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 120,
    },
    {
      title: 'Vmax-0时间(V90TO/S210)', //表头显示的名称

      dataIndex: 'decreaseTimeTO', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 120,
    },
    {
      title: '0-nmax时间(V90Speed)', //表头显示的名称

      dataIndex: 'increaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 100,
    },
    {
      title: 'nmax-0时间(V90Speed)', //表头显示的名称

      dataIndex: 'decreaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      width: 100,
    },

    {
      title: '速度环增益(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'kpEpos',
      width: 100,
    },
    {
      title: '速度环积分(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'tnEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '位置环增益(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'kprEpos',
      width: 100,
    },
    {
      title: '速度环前馈系数(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'coeffVelEpos',
      width: 120,
    },
    {
      title: '机械齿轮每圈LU(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'luLoopEpos',
      width: 120,
    },
    {
      title: '最大速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'vmaxEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 100,
    },
    {
      title: '最大加速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'accmaxEpos',
      width: 100,
    },
    {
      title: '最大减速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'dccmaxEpos',
      width: 100,
    },

    {
      title: 'Jerk(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'jerkEpos',
      width: 120,
    },
    {
      title: '速度环Kp(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'kpSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 120,
    },
    {
      title: '速度环Tn(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tnSpeed',
      width: 120,
    },
    {
      title: '斜坡上升t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tincSpeed',
      width: 100,
    },

    {
      title: '斜坡下降t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tdecSpeed',
      width: 100,
    },
    {
      title: '斜坡圆弧起始t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tstartSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 120,
    },
    {
      title: '斜坡圆弧结束t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tstopSpeed',
      width: 120,
    },
    {
      title: '速度环Kp(V90TO/S210)', //表头显示的名称
      search: false,
      dataIndex: 'kpTO',
      width: 120,
    },
    {
      title: '速度环Tn(V90TO/S210)', //表头显示的名称
      search: false,
      dataIndex: 'tnTO', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 120,
    },
    // {
    //   title: '操作',
    //   align:'center',
    //   valueType: 'option',
    //   key: 'option',
    //   fixed: 'right',
    //   render: (text, record, _, action) => [
    //     <a
    //       key="calculate"
    //       onClick={() => {
    //         Modal.confirm({
    //           title: '计算',
    //           content: '是否计算？',
    //           okText: '是',
    //           cancelText: '否',
    //           onOk: async () => {
    //             actionRef.current?.reload();
    //             message.success("计算成功！");
    //           },
    //         });
    //       }}
    //     >
    //       计算
    //     </a>,
    //   ],
    // },
  ];

  return (
    <PageHeaderWrapper title={false} breadcrumb={undefined}>
      {/* <Card title="驱动参数计算" className={styles.card} bordered={false}>
        <EditableProTable<TableFormDateType>
          value={dataSource}
          editableFormRef={editorFormRef}
          scroll={{ x: 6000 }}
          toolBarRender={(action, { selectedRows, selectedRowKeys}) => [
            <Button
              key="button"
              icon={<PlusOutlined />}
              onClick={() => {
                actionRef.current?.addEditRecord?.({
                  id: (Math.random() * 1000000).toFixed(0),
                  title: '新的一行',
                });
                setIsCreate(true);
              }}
              type="primary"
            >
              新建
            </Button>,
  
            <Button
              key="button"
              icon={<PlusOutlined />}
              onClick={() => {
                setUploadVisit(true);
              }}
              type="primary"
            >
              导入
            </Button>,
            <Button
              key="button"
              icon={<PlusOutlined />}
              onClick={() => {
                driveParaCalExcelExport().then((res) => {
                  const aLink = document.createElement('a');
                  document.body.appendChild(aLink);
                  aLink.style.display = 'none';
                  aLink.href = window.URL.createObjectURL(res);
                  aLink.setAttribute('download', `驱动参数计算${new Date()}.xlsx`);
                  aLink.click();
                  document.body.removeChild(aLink);
                });
              }}
              type="primary"
            >
              导出
            </Button>,
            <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              Modal.confirm({
                title: '计算',
                content: '是否计算？',
                okText: '是',
                cancelText: '否',
                onOk: async () => {
                  await delDriveParasCal(selectedRowKeys);
                  actionRef.current?.reload();
                  message.success("删除成功！");
                },
              });
            }}
            type="primary"
          >
            计算
          </Button>,         
            <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              Modal.confirm({
                title: '删除',
                content: '是否删除？',
                okText: '是',
                cancelText: '否',
                onOk: async () => {
                  await delDriveParasCal(selectedRowKeys);
                  actionRef.current?.reload();
                  message.success("删除成功！");
                },
              });
            }}
            type="primary"
          >
            删除
          </Button>,
          ]}
          recordCreatorProps={{
            record: () => {
              return {
                id: `0${Date.now()}`,
              };
            },
          }}
          onChange={setDataSource}
          columns={columns}
          rowKey="id"
          rowSelection={{}}
        />
      </Card> */}
      <ProTable //表格Pro组件
        headerTitle="驱动参数计算" //表头
        actionRef={actionRef} //用于触发刷新操作等，看api
        rowKey="id" //表格行 key 的取值，可以是字符串或一个函数
        FormRef={editorFormRef}
        scroll={{ x: 6000 }}
        editable={{
          type: 'multiple',
          onSave: async (rowKey, row) => {
            console.log(row);
            delete row.index;
            if (isCreate) {
              delete row.title;
              delete row.id;
              await addDriveParaCal(row);
            } else {
              await updateDriveParaCal(row);
            }
            actionRef.current?.reload();
          },
        }}
        columnsState={{
          persistenceKey: 'pro-table-singe-demos',
          persistenceType: 'localStorage',
          onChange(value) {
            console.log('value: ', value);
          },
        }}
        search={{
          labelWidth: 150,
          span: 6,
        }}
        options={{
          setting: {
            listsHeight: 400,
          },
        }}
        pagination={{
          pageSize: 5,
          onChange: (page) => console.log(page),
        }}
        dateFormatter="string"
        toolBarRender={(action, { selectedRows, selectedRowKeys }) => [
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              actionRef.current?.addEditRecord?.({
                id: (Math.random() * 1000000).toFixed(0),
                title: '新的一行',
              });
              setIsCreate(true);
            }}
            type="primary"
          >
            新建
          </Button>,

          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              setUploadVisit(true);
            }}
            type="primary"
          >
            导入
          </Button>,
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              driveParaCalExcelExport().then((res) => {
                const aLink = document.createElement('a');
                document.body.appendChild(aLink);
                aLink.style.display = 'none';
                aLink.href = window.URL.createObjectURL(res);
                aLink.setAttribute('download', `驱动参数计算${new Date()}.xlsx`);
                aLink.click();
                document.body.removeChild(aLink);
              });
            }}
            type="primary"
          >
            导出
          </Button>,
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              Modal.confirm({
                title: '计算',
                content: '是否计算？',
                okText: '是',
                cancelText: '否',
                onOk: async () => {
                  await delDriveParasCal(selectedRowKeys);
                  actionRef.current?.reload();
                  message.success('删除成功！');
                },
              });
            }}
            type="primary"
          >
            计算
          </Button>,
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              Modal.confirm({
                title: '删除',
                content: '是否删除？',
                okText: '是',
                cancelText: '否',
                onOk: async () => {
                  await delDriveParasCal(selectedRowKeys);
                  actionRef.current?.reload();
                  message.success('删除成功！');
                },
              });
            }}
            type="primary"
          >
            删除
          </Button>,
        ]}
        request={async (params = {}, sort, filter) => {
          console.log(params, sort, filter);
          const result = await getDriveParaCalByPage(params);
          console.log(result);
          return {
            data: result.data.content,
            total: result.data.totalElements,
            success: result.success,
          };
        }} //请求数据的地方，例子是用mock模拟数据，我是在后台请求的数据
        columns={columns} //上面定义的
        rowSelection={{}}
      />
      <ToeUpload
        onCancel={() => {
          setUploadVisit(false);
        }}
        ref={uploadRef}
        onOk={async () => {
          const formData = new FormData();
          console.log(uploadRef.current.fileList, '文件测试---');
          uploadRef.current.fileList.map((file) => {
            formData.append('file', file);
          });
          // formData.append('file', 'jja');
          console.log(formData, '---formData--');
          await uploadDriveParaCalExcel(formData);
          actionRef.current.reload();
          setUploadVisit(false);
        }}
        visible={uploadVisit}
        title="文件上传"
      />
    </PageHeaderWrapper>
  );
};

export default DriveParaLib;
